package com.cjy.collections;


import com.cjy.string.StringUtils;
import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * @author Cheng JiYe
 * @date 2020/3/19 22:38
 */
public class CollectionUtils<T> {
    /**
     * 检测collection是否为null或size=0
     */
    public static boolean collectionIsEmpty(Collection collection) {
        return (collection == null || collection.isEmpty());
    }


    /**
     * 检测collection不为null或size>=1
     */
    public static boolean collectionIsNotEmpty(Collection collection) {
        return !collectionIsEmpty(collection);
    }

    /**
     * 判断数组是否为空
     *
     * @param arr
     * @return
     */
    public static boolean collectionIsEmpty(Object[] arr) {
        return (arr == null || arr.length == 0);
    }


    /**
     * 初始化list，往list 中添加元素正例：
     */
    public static List<Object> listPositiveExample(Object[] arr) {
        List<Object> list;
        if (collectionIsEmpty(arr)) {
            return new ArrayList<>();
        } else {
            //指定集合list 的容量大小
            list = new ArrayList<>(arr.length);
            for (Object i : arr) {
                list.add(i);
            }
        }
        return list;
    }

    /**
     * 频繁调用Collection.contains()
     */
    public void collectionContainsPositiveExample(List<Object> list, Object object) {
        Set<Object> set = new HashSet<>();
        for (int i = 0; i <= Integer.MAX_VALUE; i++) {
            //时间复杂度为O(1)
            if (set.contains(i)) {
                System.out.println("list contains " + i);
            }
        }
    }


    /**
     * 使用for循环删除list的单个元素
     */
    public static boolean arrayListRemoveOne(List<String> list, String string) {
        StringUtils.isNotEmpty(null);
        if (collectionIsEmpty(list) || StringUtils.isEmpty(string)) {
            return false;
        }

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).contains(string)) {
                list.remove(i);
                break;
            }
        }

        return true;
    }


    /**
     * 使用迭代器删除
     */
    public static boolean arrayListRemoveMulti(List<String> list, String str) {
        if (org.apache.commons.collections.CollectionUtils.isEmpty(list) || StringUtils.isBlank(str)) {
            return false;
        }

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            if (next.contains(str)) {
                iterator.remove();
            }
        }
        return true;
    }


    /**
     * List转换成数组
     */
    public static String[] listToArrayGenericity(List<String> strList) {
        return strList.toArray(new String[strList.size()]);
    }

    /**
     * 数组转成list
     * 方法一：通过List构造方法
     * <p>
     * 通过ArrayList中一个构造方法来将数组转化成ArrayList，
     * 但是由于ArrayList中的构造方法里面没有直接以数组作为参数的方法，
     * 所以需要先通过Arrays.asList()方法进行一个简单的转化
     */
    public static List<Integer> arrayToListPassConstructor(Integer[] integerArray) {
        return new ArrayList(Arrays.asList(integerArray));
    }

    /**
     * 通过Collections
     * <p>
     * 该方式通过Collections中的addAll方法将数组里面的每一个元素通过循环的方式放入到List中，
     * 这里使用的Collections.addAll()方法源码
     */
    public static List<Integer> arrayToListPassCollections(Integer[] integerArray) {
        List<Integer> listThree = new ArrayList<>();
        Collections.addAll(listThree, integerArray);
        return listThree;
    }


    /**
     * 对 int 数组进行正序排序
     */
    public static int[] arrayPositiveSort(int[] ints) {
        Arrays.sort(ints);
        return ints;
    }


    /**
     * list正序排序
     *
     * @param list
     */
    public static void listPositive(List list) {
        Collections.sort(list);
    }

    /**
     * list倒叙排序
     *
     * @param list
     */
    public static void listFlashback(List list) {
        Collections.reverse(list);
    }

    /**
     * 判断Map是否为空
     *
     * @param map 入参
     * @return boolean
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return (map == null || map.isEmpty());
    }

    /**
     * 判断Map是否不为空
     *
     * @param map 入参
     * @return boolean
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }


    /**
     * 创建一个list
     *
     * @param <E>
     * @return ArrayList<Object>
     */
    public static <E> ArrayList<E> newArrayListSun() {
        return new ArrayList<>();
    }

    /**
     * 创建一个list
     *
     * @param <E>
     * @return List<Object>
     */
    public static <E> List<E> newArrayListSunFather() {
        return new ArrayList<>();
    }

    public static <T> List<T> newArrayListSunFathers(T object) {
        return new ArrayList<>();
    }




}
